home *** CD-ROM | disk | FTP | other *** search
/ EuroCD 3 / EuroCD 3.iso / Programming / Python1.4_Source / Modules / stropmodule.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-24  |  15.7 KB  |  805 lines
  1. /***********************************************************
  2. Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
  3. The Netherlands.
  4.  
  5.                         All Rights Reserved
  6.  
  7. Permission to use, copy, modify, and distribute this software and its
  8. documentation for any purpose and without fee is hereby granted,
  9. provided that the above copyright notice appear in all copies and that
  10. both that copyright notice and this permission notice appear in
  11. supporting documentation, and that the names of Stichting Mathematisch
  12. Centrum or CWI or Corporation for National Research Initiatives or
  13. CNRI not be used in advertising or publicity pertaining to
  14. distribution of the software without specific, written prior
  15. permission.
  16.  
  17. While CWI is the initial source for this software, a modified version
  18. is made available by the Corporation for National Research Initiatives
  19. (CNRI) at the Internet address ftp://ftp.python.org.
  20.  
  21. STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22. REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23. MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24. CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26. PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27. TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28. PERFORMANCE OF THIS SOFTWARE.
  29.  
  30. ******************************************************************/
  31.  
  32. /* strop module */
  33.  
  34. #include "allobjects.h"
  35. #include "modsupport.h"
  36.  
  37. #include <ctype.h>
  38. /* XXX This file assumes that the <ctype.h> is*() functions
  39.    XXX are defined for all 8-bit characters! */
  40.  
  41. #include <errno.h>
  42.  
  43. #include "protos/stropmodule_protos.h"
  44.  
  45. /* The lstrip(), rstrip() and strip() functions are implemented
  46.    in do_strip(), which uses an additional parameter to indicate what
  47.    type of strip should occur. */
  48.  
  49. #define LEFTSTRIP 0
  50. #define RIGHTSTRIP 1
  51. #define BOTHSTRIP 2
  52.  
  53.  
  54. static object *
  55. split_whitespace(s, len, maxsplit)
  56.     char *s;
  57.     int len;
  58.     int maxsplit;
  59. {
  60.     int i, j, err;
  61.     int countsplit;
  62.     object *list, *item;
  63.  
  64.     list = newlistobject(0);
  65.     if (list == NULL)
  66.         return NULL;
  67.  
  68.     i = 0;
  69.     countsplit = 0;
  70.  
  71.     while (i < len) {
  72.         while (i < len && isspace(Py_CHARMASK(s[i]))) {
  73.             i = i+1;
  74.         }
  75.         j = i;
  76.         while (i < len && !isspace(Py_CHARMASK(s[i]))) {
  77.             i = i+1;
  78.         }
  79.         if (j < i) {
  80.             item = newsizedstringobject(s+j, (int)(i-j));
  81.             if (item == NULL) {
  82.                 DECREF(list);
  83.                 return NULL;
  84.             }
  85.             err = addlistitem(list, item);
  86.             DECREF(item);
  87.             if (err < 0) {
  88.                 DECREF(list);
  89.                 return NULL;
  90.             }
  91.  
  92.             countsplit++;
  93.             if (maxsplit && (countsplit >= maxsplit)) {
  94.                 item = newsizedstringobject(s+i, (int)(len - i));
  95.                 if (item == NULL) {
  96.                     DECREF(list);
  97.                     return NULL;
  98.                 }
  99.                 err = addlistitem(list, item);
  100.                 DECREF(item);
  101.                 if (err < 0) {
  102.                     DECREF(list);
  103.                     return NULL;
  104.                 }
  105.                 i = len;
  106.             }
  107.     
  108.         }
  109.     }
  110.  
  111.     return list;
  112. }
  113.  
  114.  
  115. static object *
  116. strop_splitfields(self, args)
  117.     object *self; /* Not used */
  118.     object *args;
  119. {
  120.     int len, n, i, j, err;
  121.     int splitcount, maxsplit;
  122.     char *s, *sub;
  123.     object *list, *item;
  124.  
  125.     sub = NULL;
  126.     n = 0;
  127.     splitcount = 0;
  128.     maxsplit = 0;
  129.     if (!newgetargs(args, "s#|z#i", &s, &len, &sub, &n, &maxsplit))
  130.         return NULL;
  131.     if (sub == NULL)
  132.         return split_whitespace(s, len, maxsplit);
  133.     if (n == 0) {
  134.         err_setstr(ValueError, "empty separator");
  135.         return NULL;
  136.     }
  137.  
  138.     list = newlistobject(0);
  139.     if (list == NULL)
  140.         return NULL;
  141.  
  142.     i = j = 0;
  143.     while (i+n <= len) {
  144.         if (s[i] == sub[0] && (n == 1 || memcmp(s+i, sub, n) == 0)) {
  145.             item = newsizedstringobject(s+j, (int)(i-j));
  146.             if (item == NULL)
  147.                 goto fail;
  148.             err = addlistitem(list, item);
  149.             DECREF(item);
  150.             if (err < 0)
  151.                 goto fail;
  152.             i = j = i + n;
  153.             splitcount++;
  154.             if (maxsplit && (splitcount >= maxsplit))
  155.                 break;
  156.         }
  157.         else
  158.             i++;
  159.     }
  160.     item = newsizedstringobject(s+j, (int)(len-j));
  161.     if (item == NULL)
  162.         goto fail;
  163.     err = addlistitem(list, item);
  164.     DECREF(item);
  165.     if (err < 0)
  166.         goto fail;
  167.  
  168.     return list;
  169.  
  170.  fail:
  171.     DECREF(list);
  172.     return NULL;
  173. }
  174.  
  175.  
  176. static object *
  177. strop_joinfields(self, args)
  178.     object *self; /* Not used */
  179.     object *args;
  180. {
  181.     object *seq, *item, *res;
  182.     object * (*getitem) FPROTO((object *, int));
  183.     char *sep, *p;
  184.     int seplen, seqlen, reslen, itemlen, i;
  185.  
  186.     sep = NULL;
  187.     seplen = 0;
  188.     if (!newgetargs(args, "O|s#", &seq, &sep, &seplen))
  189.         return NULL;
  190.     if (sep == NULL) {
  191.         sep = " ";
  192.         seplen = 1;
  193.     }
  194.     if (is_listobject(seq)) {
  195.         getitem = getlistitem;
  196.         seqlen = getlistsize(seq);
  197.     }
  198.     else if (is_tupleobject(seq)) {
  199.         getitem = gettupleitem;
  200.         seqlen = gettuplesize(seq);
  201.     }
  202.     else {
  203.         err_setstr(TypeError, "first argument must be list/tuple");
  204.         return NULL;
  205.     }
  206.     reslen = 0;
  207.     for (i = 0; i < seqlen; i++) {
  208.         item = getitem(seq, i);
  209.         if (!is_stringobject(item)) {
  210.             err_setstr(TypeError,
  211.                "first argument must be list/tuple of strings");
  212.             return NULL;
  213.         }
  214.         if (i > 0)
  215.             reslen = reslen + seplen;
  216.         reslen = reslen + getstringsize(item);
  217.     }
  218.     if (seqlen == 1) {
  219.         /* Optimization if there's only one item */
  220.         item = getitem(seq, 0);
  221.         INCREF(item);
  222.         return item;
  223.     }
  224.     res = newsizedstringobject((char *)NULL, reslen);
  225.     if (res == NULL)
  226.         return NULL;
  227.     p = getstringvalue(res);
  228.     for (i = 0; i < seqlen; i++) {
  229.         item = getitem(seq, i);
  230.         if (i > 0) {
  231.             memcpy(p, sep, seplen);
  232.             p += seplen;
  233.         }
  234.         itemlen = getstringsize(item);
  235.         memcpy(p, getstringvalue(item), itemlen);
  236.         p += itemlen;
  237.     }
  238.     if (p != getstringvalue(res) + reslen) {
  239.         err_setstr(SystemError, "strop.joinfields: assertion failed");
  240.         return NULL;
  241.     }
  242.     return res;
  243. }
  244.  
  245.  
  246. static object *
  247. strop_find(self, args)
  248.     object *self; /* Not used */
  249.     object *args;
  250. {
  251.     char *s, *sub;
  252.     int len, n, i;
  253.  
  254.     if (getargs(args, "(s#s#i)", &s, &len, &sub, &n, &i)) {
  255.         if (i < 0)
  256.             i += len;
  257.         if (i < 0)
  258.             i = 0;
  259.     }
  260.     else {
  261.         err_clear();
  262.         if (!getargs(args, "(s#s#)", &s, &len, &sub, &n))
  263.             return NULL;
  264.         i = 0;
  265.     }
  266.  
  267.     if (n == 0)
  268.         return newintobject((long)i);
  269.  
  270.     len -= n;
  271.     for (; i <= len; ++i)
  272.         if (s[i] == sub[0] &&
  273.             (n == 1 || memcmp(&s[i+1], &sub[1], n-1) == 0))
  274.             return newintobject((long)i);
  275.  
  276.     return newintobject(-1L);
  277. }
  278.  
  279.  
  280. static object *
  281. strop_rfind(self, args)
  282.     object *self; /* Not used */
  283.     object *args;
  284. {
  285.     char *s, *sub;
  286.     int len, n, i, j;
  287.  
  288.     if (getargs(args, "(s#s#i)", &s, &len, &sub, &n, &i)) {
  289.         if (i < 0)
  290.             i += len;
  291.         if (i < 0)
  292.             i = 0;
  293.     }
  294.     else {
  295.         err_clear();
  296.         if (!getargs(args, "(s#s#)", &s, &len, &sub, &n))
  297.             return NULL;
  298.         i = 0;
  299.     }
  300.  
  301.     if (n == 0)
  302.         return newintobject((long)len);
  303.  
  304.     for (j = len-n; j >= i; --j)
  305.         if (s[j] == sub[0] &&
  306.             (n == 1 || memcmp(&s[j+1], &sub[1], n-1) == 0))
  307.             return newintobject((long)j);
  308.  
  309.     return newintobject(-1L);
  310. }
  311.  
  312. static object *
  313. do_strip(args, striptype)
  314.     object *args;
  315.     int striptype;
  316. {
  317.     char *s;
  318.     int len, i, j;
  319.  
  320.  
  321.     if (!getargs(args, "s#", &s, &len))
  322.         return NULL;
  323.  
  324.     i = 0;
  325.     if (striptype != RIGHTSTRIP) {
  326.         while (i < len && isspace(Py_CHARMASK(s[i]))) {
  327.             i++;
  328.         }
  329.     }
  330.     
  331.  
  332.     j = len;
  333.     if (striptype != LEFTSTRIP) {
  334.         do {
  335.             j--;
  336.         } while (j >= i && isspace(Py_CHARMASK(s[j])));
  337.         j++;
  338.     }
  339.  
  340.     if (i == 0 && j == len) {
  341.         INCREF(args);
  342.         return args;
  343.     }
  344.     else
  345.         return newsizedstringobject(s+i, j-i);
  346. }
  347.  
  348.  
  349. static object *
  350. strop_strip(self, args)
  351.     object *self; /* Not used */
  352.     object *args;
  353. {
  354.     return do_strip(args, BOTHSTRIP);
  355. }
  356.  
  357. static object *
  358. strop_lstrip(self, args)
  359.     object *self; /* Not used */
  360.     object *args;
  361. {
  362.     return do_strip(args, LEFTSTRIP);
  363. }
  364.  
  365. static object *
  366. strop_rstrip(self, args)
  367.     object *self; /* Not used */
  368.     object *args;
  369. {
  370.     return do_strip(args, RIGHTSTRIP);
  371. }
  372.  
  373.  
  374. static object *
  375. strop_lower(self, args)
  376.     object *self; /* Not used */
  377.     object *args;
  378. {
  379.     char *s, *s_new;
  380.     int i, n;
  381.     object *new;
  382.     int changed;
  383.  
  384.     if (!getargs(args, "s#", &s, &n))
  385.         return NULL;
  386.     new = newsizedstringobject(NULL, n);
  387.     if (new == NULL)
  388.         return NULL;
  389.     s_new = getstringvalue(new);
  390.     changed = 0;
  391.     for (i = 0; i < n; i++) {
  392.         int c = Py_CHARMASK(*s++);
  393.         if (isupper(c)) {
  394.             changed = 1;
  395.             *s_new = tolower(c);
  396.         } else
  397.             *s_new = c;
  398.         s_new++;
  399.     }
  400.     if (!changed) {
  401.         DECREF(new);
  402.         INCREF(args);
  403.         return args;
  404.     }
  405.     return new;
  406. }
  407.  
  408.  
  409. static object *
  410. strop_upper(self, args)
  411.     object *self; /* Not used */
  412.     object *args;
  413. {
  414.     char *s, *s_new;
  415.     int i, n;
  416.     object *new;
  417.     int changed;
  418.  
  419.     if (!getargs(args, "s#", &s, &n))
  420.         return NULL;
  421.     new = newsizedstringobject(NULL, n);
  422.     if (new == NULL)
  423.         return NULL;
  424.     s_new = getstringvalue(new);
  425.     changed = 0;
  426.     for (i = 0; i < n; i++) {
  427.         int c = Py_CHARMASK(*s++);
  428.         if (islower(c)) {
  429.             changed = 1;
  430.             *s_new = toupper(c);
  431.         } else
  432.             *s_new = c;
  433.         s_new++;
  434.     }
  435.     if (!changed) {
  436.         DECREF(new);
  437.         INCREF(args);
  438.         return args;
  439.     }
  440.     return new;
  441. }
  442.  
  443.  
  444. static object *
  445. strop_capitalize(self, args)
  446.     object *self; /* Not used */
  447.     object *args;
  448. {
  449.     char *s, *s_new;
  450.     int i, n;
  451.     object *new;
  452.     int changed;
  453.  
  454.     if (!getargs(args, "s#", &s, &n))
  455.         return NULL;
  456.     new = newsizedstringobject(NULL, n);
  457.     if (new == NULL)
  458.         return NULL;
  459.     s_new = getstringvalue(new);
  460.     changed = 0;
  461.     if (0 < n) {
  462.         int c = Py_CHARMASK(*s++);
  463.         if (islower(c)) {
  464.             changed = 1;
  465.             *s_new = toupper(c);
  466.         } else
  467.             *s_new = c;
  468.         s_new++;
  469.     }
  470.     for (i = 1; i < n; i++) {
  471.         int c = Py_CHARMASK(*s++);
  472.         if (isupper(c)) {
  473.             changed = 1;
  474.             *s_new = tolower(c);
  475.         } else
  476.             *s_new = c;
  477.         s_new++;
  478.     }
  479.     if (!changed) {
  480.         DECREF(new);
  481.         INCREF(args);
  482.         return args;
  483.     }
  484.     return new;
  485. }
  486.  
  487.  
  488. static object *
  489. strop_swapcase(self, args)
  490.     object *self; /* Not used */
  491.     object *args;
  492. {
  493.     char *s, *s_new;
  494.     int i, n;
  495.     object *new;
  496.     int changed;
  497.  
  498.     if (!getargs(args, "s#", &s, &n))
  499.         return NULL;
  500.     new = newsizedstringobject(NULL, n);
  501.     if (new == NULL)
  502.         return NULL;
  503.     s_new = getstringvalue(new);
  504.     changed = 0;
  505.     for (i = 0; i < n; i++) {
  506.         int c = Py_CHARMASK(*s++);
  507.         if (islower(c)) {
  508.             changed = 1;
  509.             *s_new = toupper(c);
  510.         }
  511.         else if (isupper(c)) {
  512.             changed = 1;
  513.             *s_new = tolower(c);
  514.         }
  515.         else
  516.             *s_new = c;
  517.         s_new++;
  518.     }
  519.     if (!changed) {
  520.         DECREF(new);
  521.         INCREF(args);
  522.         return args;
  523.     }
  524.     return new;
  525. }
  526.  
  527.  
  528. static object *
  529. strop_atoi(self, args)
  530.     object *self; /* Not used */
  531.     object *args;
  532. {
  533.     extern long mystrtol PROTO((const char *, char **, int));
  534.     extern unsigned long mystrtoul PROTO((const char *, char **, int));
  535.     char *s, *end;
  536.     int base = 10;
  537.     long x;
  538.     char buffer[256]; /* For errors */
  539.  
  540.     if (args != NULL && is_tupleobject(args)) {
  541.         if (!getargs(args, "(si)", &s, &base))
  542.             return NULL;
  543.         if (base != 0 && base < 2 || base > 36) {
  544.             err_setstr(ValueError, "invalid base for atoi()");
  545.             return NULL;
  546.         }
  547.     }
  548.     else if (!getargs(args, "s", &s))
  549.         return NULL;
  550.     while (*s && isspace(Py_CHARMASK(*s)))
  551.         s++;
  552.     if (s[0] == '\0') {
  553.         err_setstr(ValueError, "empty string for atoi()");
  554.         return NULL;
  555.     }
  556.     errno = 0;
  557.     if (base == 0 && s[0] == '0')
  558.         x = (long) mystrtoul(s, &end, base);
  559.     else
  560.         x = mystrtol(s, &end, base);
  561.     while (*end && isspace(Py_CHARMASK(*end)))
  562.         end++;
  563.     if (*end != '\0') {
  564.         sprintf(buffer, "invalid literal for atoi(): %.200s", s);
  565.         err_setstr(ValueError, buffer);
  566.         return NULL;
  567.     }
  568.     else if (errno != 0) {
  569.         sprintf(buffer, "atoi() literal too large: %.200s", s);
  570.         err_setstr(ValueError, buffer);
  571.         return NULL;
  572.     }
  573.     return newintobject(x);
  574. }
  575.  
  576.  
  577. static object *
  578. strop_atol(self, args)
  579.     object *self; /* Not used */
  580.     object *args;
  581. {
  582.     char *s, *end;
  583.     int base = 10;
  584.     object *x;
  585.     char buffer[256]; /* For errors */
  586.  
  587.     if (args != NULL && is_tupleobject(args)) {
  588.         if (!getargs(args, "(si)", &s, &base))
  589.             return NULL;
  590.         if (base != 0 && base < 2 || base > 36) {
  591.             err_setstr(ValueError, "invalid base for atol()");
  592.             return NULL;
  593.         }
  594.     }
  595.     else if (!getargs(args, "s", &s))
  596.         return NULL;
  597.     while (*s && isspace(Py_CHARMASK(*s)))
  598.         s++;
  599.     if (s[0] == '\0') {
  600.         err_setstr(ValueError, "empty string for atol()");
  601.         return NULL;
  602.     }
  603.     x = long_escan(s, &end, base);
  604.     if (x == NULL)
  605.         return NULL;
  606.     if (base == 0 && (*end == 'l' || *end == 'L'))
  607.         end++;
  608.     while (*end && isspace(Py_CHARMASK(*end)))
  609.         end++;
  610.     if (*end != '\0') {
  611.         sprintf(buffer, "invalid literal for atol(): %.200s", s);
  612.         err_setstr(ValueError, buffer);
  613.         DECREF(x);
  614.         return NULL;
  615.     }
  616.     return x;
  617. }
  618.  
  619.  
  620. static object *
  621. strop_atof(self, args)
  622.     object *self; /* Not used */
  623.     object *args;
  624. {
  625.     extern double strtod PROTO((const char *, char **));
  626.     char *s, *end;
  627.     double x;
  628.     char buffer[256]; /* For errors */
  629.  
  630.     if (!getargs(args, "s", &s))
  631.         return NULL;
  632.     while (*s && isspace(Py_CHARMASK(*s)))
  633.         s++;
  634.     if (s[0] == '\0') {
  635.         err_setstr(ValueError, "empty string for atof()");
  636.         return NULL;
  637.     }
  638.     errno = 0;
  639.     x = strtod(s, &end);
  640.     while (*end && isspace(Py_CHARMASK(*end)))
  641.         end++;
  642.     if (*end != '\0') {
  643.         sprintf(buffer, "invalid literal for atof(): %.200s", s);
  644.         err_setstr(ValueError, buffer);
  645.         return NULL;
  646.     }
  647.     else if (errno != 0) {
  648.         sprintf(buffer, "atof() literal too large: %.200s", s);
  649.         err_setstr(ValueError, buffer);
  650.         return NULL;
  651.     }
  652.     return newfloatobject(x);
  653. }
  654.  
  655.  
  656. static PyObject *
  657. strop_maketrans(self, args)
  658.     PyObject *self; /* Not used */
  659.     PyObject *args;
  660. {
  661.     unsigned char c[256], *from=NULL, *to=NULL;
  662.     int i, fromlen=0, tolen=0;
  663.  
  664.     if (PyTuple_Size(args)!=0) {
  665.         if (!PyArg_ParseTuple(args, "s#s#", &from, &fromlen, 
  666.                       &to, &tolen)) 
  667.             return NULL;    
  668.     }
  669.  
  670.     if (fromlen!=tolen) {
  671.         PyErr_SetString(ValueError,
  672.                 "maketrans arguments must have same length");
  673.         return NULL;
  674.     }
  675.     for(i=0; i<256; i++)
  676.         c[i]=(unsigned char)i;
  677.     for(i=0; i<fromlen; i++) {
  678.         c[from[i]]=to[i];
  679.     }
  680.     return PyString_FromStringAndSize((char *)c, 256);
  681. }
  682.  
  683.  
  684. static object *
  685. strop_translate(self, args)
  686.     object *self;
  687.     object *args;
  688. {
  689.     char *input, *table, *output, *output_start, *delete=NULL;
  690.     int inlen, tablen, dellen;
  691.     PyObject *result;
  692.     int i, trans_table[256];
  693.  
  694.     if (!PyArg_ParseTuple(args, "s#s#|s#", &input, &inlen,
  695.                   &table, &tablen, &delete, &dellen))
  696.         return NULL;
  697.     if (tablen != 256) {
  698.         PyErr_SetString(ValueError,
  699.                "translation table must be 256 characters long");
  700.         return NULL;
  701.     }
  702.     for(i=0; i<256; i++)
  703.         trans_table[i]=Py_CHARMASK(table[i]);
  704.     if (delete!=NULL) {
  705.         for(i=0; i<dellen; i++) 
  706.             trans_table[delete[i]]=-1;
  707.     }
  708.  
  709.     result = PyString_FromStringAndSize((char *)NULL, inlen);
  710.     if (result == NULL)
  711.         return NULL;
  712.     output_start = output = PyString_AsString(result);
  713.     if (delete!=NULL && dellen!=0) {
  714.         for (i = 0; i < inlen; i++) {
  715.             int c = Py_CHARMASK(*input++);
  716.             if (trans_table[c]!=-1) 
  717.                 *output++ = (char)trans_table[c];
  718.         }
  719.         /* Fix the size of the resulting string */
  720.         if (inlen > 0 &&_PyString_Resize(&result, output-output_start))
  721.             return NULL; 
  722.     } else {
  723.         /* If no deletions are required, use a faster loop */
  724.         for (i = 0; i < inlen; i++) {
  725.             int c = Py_CHARMASK(*input++);
  726.             *output++ = (char)trans_table[c];
  727.         }
  728.     }
  729.     return result;
  730. }
  731.  
  732.  
  733. /* List of functions defined in the module */
  734.  
  735. static struct methodlist strop_methods[] = {
  736.     {"atof",    strop_atof},
  737.     {"atoi",    strop_atoi},
  738.     {"atol",    strop_atol},
  739.     {"capitalize",    strop_capitalize},
  740.     {"find",    strop_find},
  741.     {"join",    strop_joinfields, 1},
  742.     {"joinfields",    strop_joinfields, 1},
  743.     {"lstrip",    strop_lstrip},
  744.     {"lower",    strop_lower},
  745.     {"rfind",    strop_rfind},
  746.     {"rstrip",    strop_rstrip},
  747.     {"split",    strop_splitfields, 1},
  748.     {"splitfields",    strop_splitfields, 1},
  749.     {"strip",    strop_strip},
  750.     {"swapcase",    strop_swapcase},
  751.     {"maketrans",    strop_maketrans, 1},
  752.     {"translate",    strop_translate, 1},
  753.     {"upper",    strop_upper},
  754.     {NULL,        NULL}    /* sentinel */
  755. };
  756.  
  757.  
  758. void
  759. initstrop()
  760. {
  761.     object *m, *d, *s;
  762.     char buf[256];
  763.     int c, n;
  764.     m = initmodule("strop", strop_methods);
  765.     d = getmoduledict(m);
  766.  
  767.     /* Create 'whitespace' object */
  768.     n = 0;
  769.     for (c = 0; c < 256; c++) {
  770.         if (isspace(c))
  771.             buf[n++] = c;
  772.     }
  773.     s = newsizedstringobject(buf, n);
  774.     if (s) {
  775.         dictinsert(d, "whitespace", s);
  776.         DECREF(s);
  777.     }
  778.     /* Create 'lowercase' object */
  779.     n = 0;
  780.     for (c = 0; c < 256; c++) {
  781.         if (islower(c))
  782.             buf[n++] = c;
  783.     }
  784.     s = newsizedstringobject(buf, n);
  785.     if (s) {
  786.         dictinsert(d, "lowercase", s);
  787.         DECREF(s);
  788.     }
  789.  
  790.     /* Create 'uppercase' object */
  791.     n = 0;
  792.     for (c = 0; c < 256; c++) {
  793.         if (isupper(c))
  794.             buf[n++] = c;
  795.     }
  796.     s = newsizedstringobject(buf, n);
  797.     if (s) {
  798.         dictinsert(d, "uppercase", s);
  799.         DECREF(s);
  800.     }
  801.  
  802.     if (err_occurred())
  803.         fatal("can't initialize module strop");
  804. }
  805.